#include "../lib/Joueur.hpp"
#include "../lib/Ville.hpp"
#include "../lib/Unite.hpp"
#include <iostream>
#include <cassert>



void Init_Joueur ( Joueur * J)
{
    for ( int i = 0 ; i < 20 ; i ++)
    {
       J->tab_ville[i] =  NULL;

    }

    for ( int i = 0 ; i < 50 ; i ++)
    {
       J->tab_unite[i] =  NULL;

    }

    J->nb_unite = 0;
    J->nb_ville = 0;
}

Joueur * Alloue_Joueur()
{
    Joueur * Temp = new Joueur;

    Init_Joueur (Temp);

    return Temp;
}


void Testament_Joueur ( Joueur * J )
{

    for ( unsigned int i = 0 ; i < J->nb_ville ; i ++)
    {
        Testament_Ville (J->tab_ville[i]);

    }

    for ( unsigned int j = 0 ; j < J->nb_unite ; j ++)
    {
        Testament_Unite (J->tab_unite[j]);

    }

    delete J;

}
static void Decaler_Tab_Ville ( Ville ** Tab, int pos, int max)
{
    for ( int i = pos ; i < max-1 ; i ++)
    {
        Tab[i]=Tab[i+1];

    }
}

static void Decaler_Tab_Unite ( Unite ** Tab, int pos, int max)
{
    if ( max > 2)
    {
        for ( int i = pos ; i < max-1 ; i ++)
        {
            Tab[i]=Tab[i+1];
        }
    }
}


void Supprimer_Ville ( Joueur * J, Ville * V)
{
    int nb_ville = J->nb_ville;
    for ( int i = 0 ; i < nb_ville ; i ++)
    {
        if ( J->tab_ville[i] == V)
        {
            Decaler_Tab_Ville ( J->tab_ville, i, nb_ville + 1);
            J->nb_ville --;
        }
    }
}

void Supprimer_Unite( Joueur * J, Unite * U )
{
    int nb_unite = J->nb_unite;

    for ( int i = 0 ; i < nb_unite ; i ++)
    {
        if ( J->tab_unite[i] == U)
        {

            Decaler_Tab_Unite ( J->tab_unite, i, nb_unite + 1 );
            J->nb_unite --;
        }

    }
}

Unite * Retourne_Unite (const Joueur * J, int i)
{
    return J->tab_unite[i];
}

Ville * Retourne_Ville (const Joueur * J, int i)
{
    return J->tab_ville[i];
}

void Ajout_Ville ( Joueur * J , Ville * v)
{
    if ( J->nb_ville < 20)
    {
        J->tab_ville[J->nb_ville]= v;
        J->nb_ville++;
    }
    //autrement on ne rajoute pas.
}

void Ajout_Unite ( Joueur * J , Unite * U)
{

    if ( J->nb_unite < 50)
    {
        J->tab_unite[J->nb_unite] = U;
        J->nb_unite++;
    }
}



int Test_Regression_Joueur ()
{
    int  i = 1;
    Unite * U = Alloue_Unite();
    Ville * V = Alloue_Ville();

    Joueur * J;
    J = Alloue_Joueur();

    assert(J->nb_unite == 0);
    assert(J->nb_ville == 0);
    assert(J->tab_ville[11] ==  NULL);
    assert(J->tab_unite[49] ==  NULL);

    Ajout_Unite( J, U);
    assert(J->nb_unite == 1);

    Ajout_Ville( J, V);
    assert(J->nb_ville == 1);

    Supprimer_Unite( J, J->tab_unite[0]);
    assert(J->nb_unite == 0);

    Supprimer_Ville( J, J->tab_ville[0]);
    assert(J->nb_ville == 0);

    Testament_Unite(U);
    Testament_Ville(V);
    Testament_Joueur (J);
    return i;
}

